Tekstbestanden inlezen

Probleem

Net als bij het schrijven van een bestand bestaat ook het lezen uit een bestand uit 4 stappen:

1. Importeer de namespace System.IO.
2. Open van het bestand en creatie van StreamReader-object voor het bestand.
3. Lees uit het bestand.
4. Sluiten van het bestand

Plaats de code voor het inlezen van een tekstbestand in een try catch finally blok.Het kan altijd gebeuren dat het bestand, dat je probeert in te lezen, niet bestaat. In de finally block sluit je de stream want die moet in beide gevallen gesloten worden.

public bool LeesMetFinally()
{
    // we gaan ervan uit dat er iets misloopt
    bool result = false;
    StreamReader sr = null;
    try
    {
        // Creëer een instantie van de StreamReader klasse om 
        // een bestand in te lezen. 
        // De StreamReader wordt gesloten in het finally blok. 
        sr = new StreamReader(this.fileName);
        // Lees tot het einde van het bestand
        this.text = sr.ReadToEnd();
        result = true;
    }
    catch (Exception e)
    {
        // Schrijf hier de code die moet worden uitgevoerd
        // als er iets mis loopt
    }
    finally
    {
        sr.Close();
    }
    return result;
}

Je moet de StreamReader buiten het try catch finally block declareren omdat de StreamReader zowel in de try blok en als in de finally blok toegankelijk moet zijn. Daarenboven moet je instantie van StreamReader initialiseren met null.

Dat moet je niet doen als je een using blok gebruikt om de stream te openen. In dat geval wordt de stream gesloten bij het afsluiten van de codeblok. Dit is de meest gebruikelijke manier in .NET.

public bool Lees()
{
    // we gaan ervan uit dat er iets misloopt
    bool result = false;
    try
    {
        // Creëer een instantie van de StreamReader klasse om
        // een bestand in te lezen.
        // Het using statement sluit ook de StreamReader.
        using (StreamReader sr = new StreamReader(this.fileName))
        {
            // Lees tot het einde van het bestand
            // this.Text = sr.ReadToEnd();
            // sr.ReadToEnd(); will get you everything, de \n en \r incluis.
            // The easiest way to get rid of most unneeded whitespace is
            // to read it line-by - line and then simply.Trim() every line.
            // zoals hieronder
            string line;
            List<string> lines = new List<string>();
            while ((line = sr.ReadLine()) != null)
                lines.Add(line.Trim());

            this.Text = string.Join("\n", lines);
                this.melding = String.Format(
                "Het bestand met de naam {0} is ingelezen.Het bevat {1} karakters en {2} woorden en {3} regels.",
                this.fileName, this.text.Length, this.text.Split(' ').Length, this.text.Split('\n').Length);
            result = true;
        }
    }
    catch (Exception e)
    {
        // Melding aan de gebruiker dat iets verkeerd gelopen is.
        // We gebruiken hier de nieuwe mogelijkheid van C# 6: string interpolatie
        this.melding = $"Kan het bestand met de naam {this.fileName} niet inlezen.\nFoutmelding {e.Message}.";
    }
    return result;
}

Vermits deze klasse data ophaalt vanaf de harde schrijf uit een bestand dat extern is aan C#, plaatsen we die klasse in de Helpers namespace omdat dit een klasse is die we in elke applicatie kunnen gebruiken. We plaatsen de code in een bestand met de naam Tekstbestand.cs en plaatsen het bestand in de submap Helpers in de root van ons project.

Design

Velden

Eigenschappen

Methoden

Oplossing: Tekstbestand.cs

using System;
using System.IO;

namespace Helpers
{
    class Tekstbestand
    {
        private string text;

        public string Text
        {
            get { return text; }
            set { text = value; }
        }

        private string melding;

        public string Melding
        {
            get { return melding; }
        }

        private string fileName;

        public string FileName
        {
            get { return fileName; }
            set
            {
                this.fileName = value;
            }
        }

        public bool Lees()
        {
            // we gaan ervan uit dat er iets misloopt
            bool result = false;
            try
            {
                // Creëer een instantie van de StreamReader klasse om 
                // een bestand in te lezen. 
                // Het using statement sluit ook de StreamReader. 
                using (StreamReader sr = new StreamReader(this.fileName))
                {
                    // Lees tot het einde van het bestand
                    this.text = sr.ReadToEnd();
                    this.melding = String.Format(
                        "Het bestand met de naam {0} is ingelezen.Het bevat {1} karakters en {2} woorden en {3} regels.",
                        this.fileName, this.text.Length, this.text.Split(' ').Length, this.text.Split('\n').Length);
                    result = true;
                }
            }
            catch (Exception e)
            {
                // Melding aan de gebruiker dat iets verkeerd gelopen is.
                // We gebruiken hier de nieuwe mogelijkheid van C# 6: string interpolatie
                this.melding = $"Kan het bestand met de naam {this.fileName} niet inlezen.\nFoutmelding {e.Message}.";
            }
            return result;
        }
    }
}

Gebruik

Je kan die klasse gebruiken om bijvoorbeeld een csv bestand in te lezen. Je schrijft een methode die de inhoud van het bestand retourneert. Ik heb die methode aan de klasse TryOut in de namespace DotNetCore.Learning:

public static string ReadFromCSVFile()
{
    Helpers.Tekstbestand bestand = new Helpers.Tekstbestand();
    bestand.FileName = @"Data\Postcodes.csv";
    bestand.Lees();
    return bestand.Text;
}

Die functie roepen we bijvoorbeeld op in de Main metthode van de Program klasse in het Program.cs bestand:

using System;

namespace DotNetCore.Learning
{
    class Program
    {
        static void Main(string[] args)
        {
            string tekst = TryOut.ReadFromCSVFile();

            Console.WriteLine(tekst);
            Console.ReadKey();
        }
    }
}